package com.orange.common.utils;

import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;

import java.util.List;
import java.util.Map;

/**
 * 对象转换工具类
 * 提供对象转Map、JSON字符串转对象、JSON字符串转Map、对象属性克隆等功能
 *
 * @Author YWF
 * @Date 2025/9/5 14:58
 */
public class ConvertUtils {
    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();

    static {
        // 初始化ObjectMapper配置
        OBJECT_MAPPER.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        OBJECT_MAPPER.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
        OBJECT_MAPPER.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        OBJECT_MAPPER.registerModule(new JavaTimeModule()); // 支持Java8时间API
    }

    /**
     * 获取ObjectMapper实例（可进行自定义配置）
     */
    public static ObjectMapper getObjectMapper() {
        return OBJECT_MAPPER;
    }

    /**
     * 对象转Map
     *
     * @param obj 要转换的对象
     * @return 转换后的Map，如果转换失败返回null
     */
    public static <T> Map<String, Object> objectToMap(T obj) {
        if (obj == null) {
            return null;
        }
        try {
            return OBJECT_MAPPER.convertValue(obj, new TypeReference<Map<String, Object>>() {
            });
        } catch (IllegalArgumentException e) {
            System.err.println("对象转Map失败: " + e.getMessage());
            return null;
        }
    }

    /**
     * JSON字符串转对象
     *
     * @param json  JSON字符串
     * @param clazz 目标对象类型
     * @param <T>   泛型类型
     * @return 转换后的对象，如果转换失败返回null
     */
    public static <T> T jsonToObject(String json, Class<T> clazz) {
        if (json == null || json.isEmpty()) {
            return null;
        }

        try {
            return OBJECT_MAPPER.readValue(json, clazz);
        } catch (JsonProcessingException e) {
            System.err.println("JSON字符串转对象失败: " + e.getMessage());
            return null;
        }
    }

    /**
     * JSON字符串转Map
     *
     * @param json JSON字符串
     * @return 转换后的Map，如果转换失败返回null
     */
    public static Map<String, Object> jsonToMap(String json) {
        if (json == null || json.isEmpty()) {
            return null;
        }

        try {
            return OBJECT_MAPPER.readValue(json, new TypeReference<Map<String, Object>>() {
            });
        } catch (JsonProcessingException e) {
            System.err.println("JSON字符串转Map失败: " + e.getMessage());
            return null;
        }
    }

    /**
     * JSON字符串转Map（指定值类型）
     *
     * @param json       JSON字符串
     * @param valueClass Map值的类型
     * @param <V>        值类型泛型
     * @return 转换后的Map，如果转换失败返回null
     */
    public static <V> Map<String, V> jsonToMap(String json, Class<V> valueClass) {
        if (json == null || json.isEmpty()) {
            return null;
        }

        try {
            JavaType type = OBJECT_MAPPER.getTypeFactory()
                    .constructMapType(Map.class, String.class, valueClass);
            return OBJECT_MAPPER.readValue(json, type);
        } catch (JsonProcessingException e) {
            System.err.println("JSON字符串转Map失败: " + e.getMessage());
            return null;
        }
    }

    /**
     * 对象属性克隆（浅拷贝）
     *
     * @param source      源对象
     * @param targetClass 目标类
     * @param <T>         源对象类型
     * @param <R>         目标对象类型
     * @return 克隆后的对象，如果转换失败返回null
     */
    public static <T, R> R cloneObject(T source, Class<R> targetClass) {
        if (source == null) {
            return null;
        }

        try {
            return OBJECT_MAPPER.convertValue(source, targetClass);
        } catch (IllegalArgumentException e) {
            System.err.println("对象克隆失败: " + e.getMessage());
            return null;
        }
    }

    /**
     * 对象转换为JSON字符串
     *
     * @param obj 要转换的对象
     * @return JSON字符串，如果转换失败返回null
     */
    public static String objectToJson(Object obj) {
        if (obj == null) {
            return null;
        }

        try {
            return OBJECT_MAPPER.writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            System.err.println("对象转JSON字符串失败: " + e.getMessage());
            return null;
        }
    }

    /**
     * 对象转换为格式化的JSON字符串
     *
     * @param obj 要转换的对象
     * @return 格式化后的JSON字符串，如果转换失败返回null
     */
    public static String objectToPrettyJson(Object obj) {
        if (obj == null) {
            return null;
        }

        try {
            return OBJECT_MAPPER.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            System.err.println("对象转格式化JSON字符串失败: " + e.getMessage());
            return null;
        }
    }

    /**
     * JSON字符串转换为List
     *
     * @param json JSON字符串
     * @param elementType 列表元素类型
     * @param <T> 元素类型泛型
     * @return 转换后的List，如果转换失败返回null
     */
    public static <T> List<T> jsonToList(String json, Class<T> elementType) {
        if (json == null || json.isEmpty()) {
            return null;
        }

        try {
            JavaType type = OBJECT_MAPPER.getTypeFactory()
                    .constructCollectionType(List.class, elementType);
            return OBJECT_MAPPER.readValue(json, type);
        } catch (Exception e) {
            System.err.println("JSON字符串转List失败: " + e.getMessage());
            return null;
        }
    }

    /**
     * JSON字符串转换为List（使用TypeReference）
     *
     * @param json JSON字符串
     * @param typeReference TypeReference对象
     * @param <T> 泛型类型
     * @return 转换后的List，如果转换失败返回null
     */
    public static <T> List<T> jsonToList(String json, TypeReference<List<T>> typeReference) {
        if (json == null || json.isEmpty()) {
            return null;
        }

        try {
            return OBJECT_MAPPER.readValue(json, typeReference);
        } catch (Exception e) {
            System.err.println("JSON字符串转List失败: " + e.getMessage());
            return null;
        }
    }

    /**
     * JSON字符串转对象（支持泛型）
     *
     * @param json JSON字符串
     * @param typeReference TypeReference对象
     * @param <T> 泛型类型
     * @return 转换后的对象，如果转换失败返回null
     */
    public static <T> T jsonToObject(String json, TypeReference<T> typeReference) {
        if (json == null || json.isEmpty()) {
            return null;
        }

        try {
            return OBJECT_MAPPER.readValue(json, typeReference);
        } catch (JsonProcessingException e) {
            System.err.println("JSON字符串转对象失败: " + e.getMessage());
            return null;
        }
    }

    /**
     * JSON字符串转对象（支持复杂泛型类型）
     *
     * @param json JSON字符串
     * @param type 复杂类型
     * @param <T> 泛型类型
     * @return 转换后的对象，如果转换失败返回null
     */
    public static <T> T jsonToObject(String json, JavaType type) {
        if (json == null || json.isEmpty()) {
            return null;
        }

        try {
            return OBJECT_MAPPER.readValue(json, type);
        } catch (JsonProcessingException e) {
            System.err.println("JSON字符串转对象失败: " + e.getMessage());
            return null;
        }
    }

    /**
     * 创建JavaType用于复杂泛型类型
     *
     * @param parametrized 参数化类型
     * @param parameterClasses 参数类
     * @return JavaType对象
     */
    public static JavaType createJavaType(Class<?> parametrized, Class<?>... parameterClasses) {
        return OBJECT_MAPPER.getTypeFactory().constructParametricType(parametrized, parameterClasses);
    }

    /**
     * 将 JSONObject 转换为指定类型的对象
     * @param jsonObject JSONObject 对象
     * @param valueType 目标类型
     * @return 转换后的对象
     */
    public static <T> T convertToObject(JSONObject jsonObject, Class<T> valueType) {
        try {
            return OBJECT_MAPPER.convertValue(jsonObject.getInnerMap(), valueType);
        } catch (Exception e) {
            System.err.println("转换失败: " + e.getMessage());
            return null;
        }
    }
}
